闭包
当内部函数被保存到外部时，将会生成闭包。闭包会导致原有作用域链不释放，造成内存泄露；两个函数相互嵌套，把里面的函数保存到了外部函数的外部，简化说把里面保存到了外部全局，里面函数执行时，一定能够调用它所在环境的变量

闭包的作用
实现公有变量
累加器
<script type="text/javascript">
	function add(){
		var count = 0;
		function demo(){
			count ++;
			document.write(count)
		}
		return demo;
	}
	var counter = add();
	counter();//调用一次加一次，统计次数；方法的执行相当于累加一次；更加结构化，看起来更好
</script>

//利用闭包实现不依赖外部变量，并且能反复执行的函数累加器
<script type="text/javascript">
	var count = 0;
	function test(){
		count ++;
		console.log(count);
	}
	test();//依赖全局变量的累加器
	test()
</script>

可以做缓存（存储结构） eg：eater；外部不可见但确实是存储结构，用的时候拿
<script type="text/javascript">
	function test(){
		var num = 100;
		function a(){
			num ++;
			console.log(num);
		}
		//a defined  -- 0 testAO
		//           -- 1 GO
		function b(){
			num --;
			console.log(num);
		}
		//b defined -- 0 testAO
		//			   1 GO
		return [a,b];
	}
	var myArr = test();//myArr接收数组ab
	myArr[0]();//执行function a
	//a doing		a.[[scope]]		0 -- aAO
	//								1 -- testAO
	//								2 --GO
	myArr[1]();//执行function b
	//b doing		b.[[scope]]		0 -- bAO
	//								1 -- testAO
	//								2 -- GO
</script>

<script type="text/javascript">
	function eater(){
		var food = '';//food相当于隐式的存储结构，虽然说没表现出来，但是却是当存储结构用的
		var obj = {
			eat : function (){
				console.log('I am eating ' + food);
				food = '';
			},
			push : function (myfood){
			food = myfood;
			}
		}
		return obj;
	}
	var eater1 = eater();

	eater1.push('banana');
	eater1.eat();
</script>

//多个函数和一个函数生成闭包，他们之间的变量可以公用，大家保存的是同一个域，就相当于全局的变量修改访问
<script type="text/javascript">
	function test(){
		var food = 'apple';
		var obj = {
			eatfood : function eat (){
				if(food != ''){
					console.log('i am eating ' + food)
				}else{
					console.log('there is nothing')
				}
				food = ''
			},
			pushfood : function push(myfood){
				food = myfood
			}
		}
		return obj
	}

	var toeat = test();//这样一个结构像缓存，储存的空间被保存到看不见的地方，下次拿的上次修改的结果
	toeat.eatfood();
	toeat.eatfood();
	toeat.pushfood('pear');
	toeat.eatfood()
</script>





可以实现封装，属性私有化 eg:Person();

模块化开发，防止污染全局变量
